package code19_jdk8.lambda;

import java.util.Arrays;
import java.util.Comparator;

public class Test01 {

	public static void main(String[] args) {
		
		String[] arr = {"aaa", "bb", "c"};
		// 1.
		Arrays.sort(arr, new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				return o1.length() - o2.length();
			}
		});
		// 是匿名内部类的简化 (Lambda)
		// 2.
		Arrays.sort(arr,
			(String o1, String o2) -> {
				return o1.length() - o2.length();
			}
		);
		// 3.
		Arrays.sort(arr,
			(o1, o2) -> {
				return o1.length() - o2.length();
			}
		);
		// 4.
		Arrays.sort(arr,
			(o1, o2) -> o1.length() - o2.length()
		);
		
		//类型 变量名 = 值;
		// Lambda表达式 的简写, 不能单独编写, 必须依赖 函数式接口
		// 1.不需要参数, 返回值为 5
		Inter1 n1 = () -> 5;
		// 2.接收一个参数(数字类型), 返回其2倍的值
		Inter2 n2 = x -> 2 * x;
		// 3.接收两个int类型的参数，返回他们的和
		Inter3 n3 = (int x, int y) -> x + y;
		// 4.接收两个(数字类型)的参数，返回他们的差
		Inter3 n4 = (x, y) -> x - y;
		// 5.接收一个String类型的参数, 并输出其值, 不返回任何值
		Inter5 n5 = (String s) -> System.out.println(s);
		// 6.接收两个int类型的参数，返回他们的乘积
		Inter3 n6 = (int x, int y) -> {
			int m = x * y;
			return m;
		};
		Inter6 n62 = (int x, int y) -> {
			int m = x * y;
			return m;
		};
		// 7.接收两个int类型的参数，输出他们的乘积
		Inter7 n7 = (int x, int y) -> {
			int m = x * y;
			System.out.println(m);
		};
		
		// 使用 变量调用内部的唯一(抽象)方法
		int f3 = n6.f3(3, 6);
		System.out.println("f3:" + f3);// 18
		
		System.out.println("-----------");
		doNum(2, 4, n6);
		System.out.println("-----------");
		doNum(2, 4, (a, b) -> (int) Math.pow(a, b) );
	}
	
	public static void doNum(int m, int n, Inter3 n3) {
		int f3 = n3.f3(m, n);
		System.out.println("doNum:"+f3);
	}
}
// 对应的接口, 只能有一个抽象方法
interface Inter1 {
	int f1();
}
interface Inter2 {
	int f2(int n);
}
interface Inter3 {
	int f3(int n, int m);
}
interface Inter5 {
	void f5(String str);
}
interface Inter6 {
	long f6(int a, int b);
}
interface Inter7 {
	void f7(int a, int b);
}